import manifest from '@/manifest.json';
// 工具封装


// #ifdef H5
/**
 * @description 微信公众号扫码
 */
export function wxPublicScanQRCode(callback = () => {}) {
    let result = isWeChatBrowser();
    if (result) {
        //配置校验成功后执行
        if (jWeixin) {
            jWeixin.ready(() => {
                jWeixin.scanQRCode({
                    needResult: needResult, // 默认为0，扫描结果由微信处理，1则直接返回扫描结果，
                    scanType: ["qrCode", "barCode"], // 可以指定扫二维码还是一维码，默认二者都有
                    success: (res) => {
                        callback(res);
                    }
                });
            });
        } else {
            uni.showToast({
                icon: 'none',
                title: "微信SDK未配置,请检查"
            });
        }
    } else {
        uni.showToast({
            icon: 'none',
            title: "请在微信客户端浏览器调用"
        });
    }
}

/**
 * @description 是否是微信浏览器
 * @return 是否
 */
export function isWeChatBrowser() {
    let ua = navigator.userAgent.toLowerCase();
    return ua.match(/MicroMessenger/i) == "micromessenger" ? true : false;
}

/**
 * @description 获取url中的参数
 * @return 参数对象
 */
export function getUrlParams() {

    // 精简版
    // q = {};
    // location.search.replace(/([^?&=]+)=([^&]+)/g, (_, k, v) => q[k] = v);

    let strs;
    let url = decodeURIComponent(window.location.href); //获取url中"?"符后的字串
    let params = new Object();
    if (url.indexOf("?") != -1) {
        url = url.substr(url.indexOf("?"));
        let str = url.substr(1);
        strs = str.split("&");
        for (let i = 0; i < strs.length; i++) {
            let index = strs[i].indexOf("=");
            let value = strs[i].slice(index + 1, strs[i].length);
            if (value.indexOf('#') > -1) {
                params[strs[i].slice(0, index)] = value.substring(0, value.indexOf('#'))
            } else {
                params[strs[i].slice(0, index)] = value;
            }
        }
    }
    return params;
}

/**
 * @description 转换对象为url参数
 * @return url参数字符串
 */
export function encodeParams(params, isPrefix = true) {
    let prefix = isPrefix ? '?' : ''
    let _result = []
    for (let key in params) {
        let value = params[key]
        // 去掉为空的参数
        if (['', undefined, null].includes(value)) {
            continue
        }
        if (value.constructor === Array) {
            value.forEach(_value => {
                _result.push(encodeURIComponent(key) + '[]=' + encodeURIComponent(_value))
            })
        } else {
            _result.push(encodeURIComponent(key) + '=' + encodeURIComponent(value))
        }
    }
    return _result.length ? prefix + _result.join('&') : ''
}
// #endif

/**
 * @description 查询节点信息
 * @param String selector 类名
 * @param String all 是否全部
 * @param Promise then 结果
 */
export function getRect(selector, all) {
    return new Promise(resolve => {
        uni.createSelectorQuery().
        in(this)[all ? 'selectAll' : 'select'](selector)
            .boundingClientRect(rect => {
                if (all && Array.isArray(rect) && rect.length) {
                    resolve(rect)
                }
                if (!all && rect) {
                    resolve(rect)
                }
            })
            .exec()
    })
};


// 识别深色还是浅色
export function isDarkColor(color) {
    let rgb = hexToRgb(color);
    return (
        0.213 * rgb.r +
        0.715 * rgb.g +
        0.072 * rgb.b >
        255 / 2
    );
}

// 16进制颜色转换RGB
export function hexToRgb(hex) {
    let result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
    return result ? {
        r: parseInt(result[1], 16),
        g: parseInt(result[2], 16),
        b: parseInt(result[3], 16)
    } : null;
}

// RGB转16进制颜色
export function rgbToHex(hex) {
    return "#" + toHex(r) + toHex(g) + toHex(b)
}

function toHex(n) {
    n = parseInt(n, 10);
    if (isNaN(n)) return "00";
    n = Math.max(0, Math.min(n, 255));
    return "0123456789ABCDEF".charAt((n - n % 16) / 16) +
        "0123456789ABCDEF".charAt(n % 16);
}

/**
 * @description 转换Rpx字符串
 * @param String || Number val 转换值
 */
export function transRpx(val) {
    return /[rpx]/.test(val) ? val : `${val}rpx`;
}

/**
 * @description 判断内容是否是数组
 * @param {Array} arr 数组
 * @return {Boolean}
 */
export function isArray(arr) {
    return Object.prototype.toString.call(arr) === '[object Array]';
}

/**
 * @description 对象深度克隆
 * @param {Object} obj 克隆对象
 * @return {Object}
 */
export function deepClone(obj) {
    // 对常见的“非”值，直接返回原来值
    if ([null, undefined, NaN, false].includes(obj)) return obj;
    if (typeof obj !== "object" && typeof obj !== 'function') {
        //原始类型直接返回
        return obj;
    }
    var o = isArray(obj) ? [] : {};
    for (let i in obj) {
        if (obj.hasOwnProperty(i)) {
            o[i] = typeof obj[i] === "object" ? deepClone(obj[i]) : obj[i];
        }
    }
    return o;
}

/**
 * @description 对象深度合并
 * @param {Object} target 目标对象
 * @param {Object} source 源对象
 * @return {Object}
 */
export function deepMerge(target = {}, source = {}) {
    target = deepClone(target);
    if (typeof target !== 'object' || typeof source !== 'object') return false;
    for (var prop in source) {
        if (!source.hasOwnProperty(prop)) continue;
        if (prop in target) {
            if (typeof target[prop] !== 'object') {
                target[prop] = source[prop];
            } else {
                if (typeof source[prop] !== 'object') {
                    target[prop] = source[prop];
                } else {
                    if (target[prop].concat && source[prop].concat) {
                        target[prop] = target[prop].concat(source[prop]);
                    } else {
                        target[prop] = deepMerge(target[prop], source[prop]);
                    }
                }
            }
        } else {
            target[prop] = source[prop];
        }
    }
    return target;
}


/**
 * @description 函数防抖 短时间内多次触发同一事件，只执行最后一次，或者只执行最开始的一次，中间的不执行
 * @param Function func 目标函数
 * @param Number wait 延迟执行毫秒数
 * @param Booleans immediate true - 立即执行， false - 延迟执行
 */
let timeout = null;
export function debounce(func, wait = 500, immediate = false) {
    // 清除定时器
    if (timeout !== null) clearTimeout(timeout);
    // 立即执行，此类情况一般用不到
    if (immediate) {
        var callNow = !timeout;
        timeout = setTimeout(function() {
            timeout = null;
        }, wait);
        if (callNow) typeof func === 'function' && func();
    } else {
        // 设置定时器，当最后一次操作后，timeout不会再被清除，所以在延时wait毫秒后执行func回调方法
        timeout = setTimeout(function() {
            typeof func === 'function' && func();
        }, wait);
    }
};

/**
 * @description 函数节流 连续触发事件但是在 n 秒中只执行一次函数。即 2n 秒内执行 2 次
 * @param Function func 函数
 * @param Number wait 延迟执行毫秒数
 * @param Number type 1 表时间戳版，2 表定时器版
 */
let timer, flag;
export function throttling(func, wait = 500, immediate = true) {
    if (immediate) {
        if (!flag) {
            flag = true;
            // 如果是立即执行，则在wait毫秒内开始时执行
            typeof func === 'function' && func();
            timer = setTimeout(() => {
                flag = false;
            }, wait);
        }
    } else {
        if (!flag) {
            flag = true
            // 如果是非立即执行，则在wait毫秒内的结束处执行
            timer = setTimeout(() => {
                flag = false
                typeof func === 'function' && func();
            }, wait);
        }

    }
}

/**
 * @description 获取设备信息
 */
export function getDeviceInfo(callback = () => {}) {
    let device = {};
    // #ifdef APP-PLUS
    uni.getSystemInfo({
        success: (systemInfo) => {
            Object.assign(device, systemInfo);
            plus.runtime.getProperty(plus.runtime.appid, (widgetInfo) => {
                Object.assign(device, widgetInfo);
                plus.device.getInfo({
                    success: (info) => {
                        Object.assign(device, info);
                        device.appid = manifest.appid;
                        callback(device)
                    }
                })
            });
        }
    });
    // #endif
    // #ifndef APP-PLUS
    uni.getSystemInfo({
        success: (systemInfo) => {
            Object.assign(device, systemInfo, manifest);
            device.appid = manifest.appid;
            callback(device)
        }
    });
    // #endif
}

// #ifdef MP-WEIXIN
/**
 * @description 检测微信小程序更新
 */
export function checkWxMpUpdate() {
    if (uni.getUpdateManager) {
        const updateManager = uni.getUpdateManager();
        updateManager.onCheckForUpdate((res) => {});
        updateManager.onUpdateReady((res) => {
            uni.showModal({
                title: '更新提示',
                content: '新版本已经准备好，是否重启应用？',
                success(res) {
                    if (res.confirm) {
                        updateManager.applyUpdate();
                    }
                }
            });
        });
        updateManager.onUpdateFailed((res) => {
            // 新的版本下载失败
            uni.showModal({
                title: '已经有新版本了哟~',
                content: '新版本已经上线啦~，请您删除当前小程序，重新搜索打开~',
                showCancel: false
            });
        });
    }
}
// #endif
